home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / urlparse.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  12KB  |  474 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Parse (absolute and relative) URLs.
  5.  
  6. See RFC 1808: "Relative Uniform Resource Locators", by R. Fielding,
  7. UC Irvine, June 1995.
  8. '''
  9. __all__ = [
  10.     'urlparse',
  11.     'urlunparse',
  12.     'urljoin',
  13.     'urldefrag',
  14.     'urlsplit',
  15.     'urlunsplit']
  16. uses_relative = [
  17.     'ftp',
  18.     'http',
  19.     'gopher',
  20.     'nntp',
  21.     'imap',
  22.     'wais',
  23.     'file',
  24.     'https',
  25.     'shttp',
  26.     'mms',
  27.     'prospero',
  28.     'rtsp',
  29.     'rtspu',
  30.     '',
  31.     'sftp']
  32. uses_netloc = [
  33.     'ftp',
  34.     'http',
  35.     'gopher',
  36.     'nntp',
  37.     'telnet',
  38.     'imap',
  39.     'wais',
  40.     'file',
  41.     'mms',
  42.     'https',
  43.     'shttp',
  44.     'snews',
  45.     'prospero',
  46.     'rtsp',
  47.     'rtspu',
  48.     'rsync',
  49.     '',
  50.     'svn',
  51.     'svn+ssh',
  52.     'sftp']
  53. non_hierarchical = [
  54.     'gopher',
  55.     'hdl',
  56.     'mailto',
  57.     'news',
  58.     'telnet',
  59.     'wais',
  60.     'imap',
  61.     'snews',
  62.     'sip',
  63.     'sips']
  64. uses_params = [
  65.     'ftp',
  66.     'hdl',
  67.     'prospero',
  68.     'http',
  69.     'imap',
  70.     'https',
  71.     'shttp',
  72.     'rtsp',
  73.     'rtspu',
  74.     'sip',
  75.     'sips',
  76.     'mms',
  77.     '',
  78.     'sftp']
  79. uses_query = [
  80.     'http',
  81.     'wais',
  82.     'imap',
  83.     'https',
  84.     'shttp',
  85.     'mms',
  86.     'gopher',
  87.     'rtsp',
  88.     'rtspu',
  89.     'sip',
  90.     'sips',
  91.     '']
  92. uses_fragment = [
  93.     'ftp',
  94.     'hdl',
  95.     'http',
  96.     'gopher',
  97.     'news',
  98.     'nntp',
  99.     'wais',
  100.     'https',
  101.     'shttp',
  102.     'snews',
  103.     'file',
  104.     'prospero',
  105.     '']
  106. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  107. MAX_CACHE_SIZE = 20
  108. _parse_cache = { }
  109.  
  110. def clear_cache():
  111.     '''Clear the parse cache.'''
  112.     global _parse_cache
  113.     _parse_cache = { }
  114.  
  115.  
  116. class BaseResult(tuple):
  117.     '''Base class for the parsed result objects.
  118.  
  119.     This provides the attributes shared by the two derived result
  120.     objects as read-only properties.  The derived classes are
  121.     responsible for checking the right number of arguments were
  122.     supplied to the constructor.
  123.  
  124.     '''
  125.     __slots__ = ()
  126.     
  127.     def scheme(self):
  128.         return self[0]
  129.  
  130.     scheme = property(scheme)
  131.     
  132.     def netloc(self):
  133.         return self[1]
  134.  
  135.     netloc = property(netloc)
  136.     
  137.     def path(self):
  138.         return self[2]
  139.  
  140.     path = property(path)
  141.     
  142.     def query(self):
  143.         return self[-2]
  144.  
  145.     query = property(query)
  146.     
  147.     def fragment(self):
  148.         return self[-1]
  149.  
  150.     fragment = property(fragment)
  151.     
  152.     def username(self):
  153.         netloc = self.netloc
  154.         if '@' in netloc:
  155.             userinfo = netloc.split('@', 1)[0]
  156.             if ':' in userinfo:
  157.                 userinfo = userinfo.split(':', 1)[0]
  158.             
  159.             return userinfo
  160.         
  161.  
  162.     username = property(username)
  163.     
  164.     def password(self):
  165.         netloc = self.netloc
  166.         if '@' in netloc:
  167.             userinfo = netloc.split('@', 1)[0]
  168.             if ':' in userinfo:
  169.                 return userinfo.split(':', 1)[1]
  170.             
  171.         
  172.  
  173.     password = property(password)
  174.     
  175.     def hostname(self):
  176.         netloc = self.netloc
  177.         if '@' in netloc:
  178.             netloc = netloc.split('@', 1)[1]
  179.         
  180.         if ':' in netloc:
  181.             netloc = netloc.split(':', 1)[0]
  182.         
  183.         if not netloc.lower():
  184.             pass
  185.  
  186.     hostname = property(hostname)
  187.     
  188.     def port(self):
  189.         netloc = self.netloc
  190.         if '@' in netloc:
  191.             netloc = netloc.split('@', 1)[1]
  192.         
  193.         if ':' in netloc:
  194.             port = netloc.split(':', 1)[1]
  195.             return int(port, 10)
  196.         
  197.  
  198.     port = property(port)
  199.  
  200.  
  201. class SplitResult(BaseResult):
  202.     __slots__ = ()
  203.     
  204.     def __new__(cls, scheme, netloc, path, query, fragment):
  205.         return BaseResult.__new__(cls, (scheme, netloc, path, query, fragment))
  206.  
  207.     
  208.     def geturl(self):
  209.         return urlunsplit(self)
  210.  
  211.  
  212.  
  213. class ParseResult(BaseResult):
  214.     __slots__ = ()
  215.     
  216.     def __new__(cls, scheme, netloc, path, params, query, fragment):
  217.         return BaseResult.__new__(cls, (scheme, netloc, path, params, query, fragment))
  218.  
  219.     
  220.     def params(self):
  221.         return self[3]
  222.  
  223.     params = property(params)
  224.     
  225.     def geturl(self):
  226.         return urlunparse(self)
  227.  
  228.  
  229.  
  230. def urlparse(url, scheme = '', allow_fragments = True):
  231.     """Parse a URL into 6 components:
  232.     <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
  233.     Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
  234.     Note that we don't break the components up in smaller bits
  235.     (e.g. netloc is a single string) and we don't expand % escapes."""
  236.     tuple = urlsplit(url, scheme, allow_fragments)
  237.     (scheme, netloc, url, query, fragment) = tuple
  238.     if scheme in uses_params and ';' in url:
  239.         (url, params) = _splitparams(url)
  240.     else:
  241.         params = ''
  242.     return ParseResult(scheme, netloc, url, params, query, fragment)
  243.  
  244.  
  245. def _splitparams(url):
  246.     if '/' in url:
  247.         i = url.find(';', url.rfind('/'))
  248.         if i < 0:
  249.             return (url, '')
  250.         
  251.     else:
  252.         i = url.find(';')
  253.     return (url[:i], url[i + 1:])
  254.  
  255.  
  256. def _splitnetloc(url, start = 0):
  257.     delim = len(url)
  258.     for c in '/?#':
  259.         wdelim = url.find(c, start)
  260.         if wdelim >= 0:
  261.             delim = min(delim, wdelim)
  262.             continue
  263.     
  264.     return (url[start:delim], url[delim:])
  265.  
  266.  
  267. def urlsplit(url, scheme = '', allow_fragments = True):
  268.     """Parse a URL into 5 components:
  269.     <scheme>://<netloc>/<path>?<query>#<fragment>
  270.     Return a 5-tuple: (scheme, netloc, path, query, fragment).
  271.     Note that we don't break the components up in smaller bits
  272.     (e.g. netloc is a single string) and we don't expand % escapes."""
  273.     allow_fragments = bool(allow_fragments)
  274.     key = (url, scheme, allow_fragments, type(url), type(scheme))
  275.     cached = _parse_cache.get(key, None)
  276.     if cached:
  277.         return cached
  278.     
  279.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  280.         clear_cache()
  281.     
  282.     netloc = query = fragment = ''
  283.     i = url.find(':')
  284.     if i > 0:
  285.         if url[:i] == 'http':
  286.             scheme = url[:i].lower()
  287.             url = url[i + 1:]
  288.             if url[:2] == '//':
  289.                 (netloc, url) = _splitnetloc(url, 2)
  290.             
  291.             if allow_fragments and '#' in url:
  292.                 (url, fragment) = url.split('#', 1)
  293.             
  294.             if '?' in url:
  295.                 (url, query) = url.split('?', 1)
  296.             
  297.             v = SplitResult(scheme, netloc, url, query, fragment)
  298.             _parse_cache[key] = v
  299.             return v
  300.         
  301.         for c in url[:i]:
  302.             if c not in scheme_chars:
  303.                 break
  304.                 continue
  305.         else:
  306.             scheme = url[:i].lower()
  307.             url = url[i + 1:]
  308.     
  309.     if scheme in uses_netloc and url[:2] == '//':
  310.         (netloc, url) = _splitnetloc(url, 2)
  311.     
  312.     if allow_fragments and scheme in uses_fragment and '#' in url:
  313.         (url, fragment) = url.split('#', 1)
  314.     
  315.     if scheme in uses_query and '?' in url:
  316.         (url, query) = url.split('?', 1)
  317.     
  318.     v = SplitResult(scheme, netloc, url, query, fragment)
  319.     _parse_cache[key] = v
  320.     return v
  321.  
  322.  
  323. def urlunparse(.0):
  324.     '''Put a parsed URL back together again.  This may result in a
  325.     slightly different, but equivalent URL, if the URL that was parsed
  326.     originally had redundant delimiters, e.g. a ? with an empty query
  327.     (the draft states that these are equivalent).'''
  328.     (scheme, netloc, url, params, query, fragment) = .0
  329.     if params:
  330.         url = '%s;%s' % (url, params)
  331.     
  332.     return urlunsplit((scheme, netloc, url, query, fragment))
  333.  
  334.  
  335. def urlunsplit(.0):
  336.     (scheme, netloc, url, query, fragment) = .0
  337.     if (netloc or scheme) and scheme in uses_netloc and url[:2] != '//':
  338.         if url and url[:1] != '/':
  339.             url = '/' + url
  340.         
  341.         if not netloc:
  342.             pass
  343.         url = '//' + '' + url
  344.     
  345.     if scheme:
  346.         url = scheme + ':' + url
  347.     
  348.     if query:
  349.         url = url + '?' + query
  350.     
  351.     if fragment:
  352.         url = url + '#' + fragment
  353.     
  354.     return url
  355.  
  356.  
  357. def urljoin(base, url, allow_fragments = True):
  358.     '''Join a base URL and a possibly relative URL to form an absolute
  359.     interpretation of the latter.'''
  360.     if not base:
  361.         return url
  362.     
  363.     if not url:
  364.         return base
  365.     
  366.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  367.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  368.     if scheme != bscheme or scheme not in uses_relative:
  369.         return url
  370.     
  371.     if scheme in uses_netloc:
  372.         if netloc:
  373.             return urlunparse((scheme, netloc, path, params, query, fragment))
  374.         
  375.         netloc = bnetloc
  376.     
  377.     if path[:1] == '/':
  378.         return urlunparse((scheme, netloc, path, params, query, fragment))
  379.     
  380.     if not path and params or query:
  381.         return urlunparse((scheme, netloc, bpath, bparams, bquery, fragment))
  382.     
  383.     segments = bpath.split('/')[:-1] + path.split('/')
  384.     if segments[-1] == '.':
  385.         segments[-1] = ''
  386.     
  387.     while '.' in segments:
  388.         segments.remove('.')
  389.     while None:
  390.         i = 1
  391.         n = len(segments) - 1
  392.         while i < n:
  393.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  394.                 del segments[i - 1:i + 1]
  395.                 break
  396.             
  397.             i = i + 1
  398.         break
  399.         continue
  400.         if segments == [
  401.             '',
  402.             '..']:
  403.             segments[-1] = ''
  404.         elif len(segments) >= 2 and segments[-1] == '..':
  405.             segments[-2:] = [
  406.                 '']
  407.         
  408.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  409.  
  410.  
  411. def urldefrag(url):
  412.     '''Removes any existing fragment from URL.
  413.  
  414.     Returns a tuple of the defragmented URL and the fragment.  If
  415.     the URL contained no fragments, the second element is the
  416.     empty string.
  417.     '''
  418.     if '#' in url:
  419.         (s, n, p, a, q, frag) = urlparse(url)
  420.         defrag = urlunparse((s, n, p, a, q, ''))
  421.         return (defrag, frag)
  422.     else:
  423.         return (url, '')
  424.  
  425. test_input = '\n      http://a/b/c/d\n\n      g:h        = <URL:g:h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      g          = <URL:http://a/b/c/g>\n      ./g        = <URL:http://a/b/c/g>\n      g/         = <URL:http://a/b/c/g/>\n      /g         = <URL:http://a/g>\n      //g        = <URL:http://g>\n      ?y         = <URL:http://a/b/c/d?y>\n      g?y        = <URL:http://a/b/c/g?y>\n      g?y/./x    = <URL:http://a/b/c/g?y/./x>\n      .          = <URL:http://a/b/c/>\n      ./         = <URL:http://a/b/c/>\n      ..         = <URL:http://a/b/>\n      ../        = <URL:http://a/b/>\n      ../g       = <URL:http://a/b/g>\n      ../..      = <URL:http://a/>\n      ../../g    = <URL:http://a/g>\n      ../../../g = <URL:http://a/../g>\n      ./../g     = <URL:http://a/b/g>\n      ./g/.      = <URL:http://a/b/c/g/>\n      /./g       = <URL:http://a/./g>\n      g/./h      = <URL:http://a/b/c/g/h>\n      g/../h     = <URL:http://a/b/c/h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      http:?y         = <URL:http://a/b/c/d?y>\n      http:g?y        = <URL:http://a/b/c/g?y>\n      http:g?y/./x    = <URL:http://a/b/c/g?y/./x>\n'
  426.  
  427. def test():
  428.     import sys as sys
  429.     base = ''
  430.     if sys.argv[1:]:
  431.         fn = sys.argv[1]
  432.         if fn == '-':
  433.             fp = sys.stdin
  434.         else:
  435.             fp = open(fn)
  436.     else:
  437.         
  438.         try:
  439.             StringIO = StringIO
  440.             import cStringIO
  441.         except ImportError:
  442.             StringIO = StringIO
  443.             import StringIO
  444.  
  445.         fp = StringIO(test_input)
  446.     while None:
  447.         line = fp.readline()
  448.         if not line:
  449.             break
  450.         
  451.         words = line.split()
  452.         if not words:
  453.             continue
  454.         
  455.         url = words[0]
  456.         parts = urlparse(url)
  457.         print '%-10s : %s' % (url, parts)
  458.         abs = urljoin(base, url)
  459.         if not base:
  460.             base = abs
  461.         
  462.         wrapped = '<URL:%s>' % abs
  463.         print '%-10s = %s' % (url, wrapped)
  464.         if len(words) == 3 and words[1] == '=':
  465.             if wrapped != words[2]:
  466.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  467.             
  468.         continue
  469.         return None
  470.  
  471. if __name__ == '__main__':
  472.     test()
  473.  
  474.